package 炫彩元素类

import (
	xc "gitee.com/go_888/xcgui/xcgui/xc"
	xcc "gitee.com/go_888/xcgui/xcgui/xcc"
)

// 列表.
type X结构_列表 struct {
	X结构_滚动视图
}

// 列表_创建, 创建列表元素.
//
// x: 元素x坐标.
//
// y: 元素y坐标.
//
// cx: 宽度.
//
// cy: 高度.
//
// hParent: 父是窗口资源句柄或UI元素资源句柄. 如果是窗口资源句柄将被添加到窗口, 如果是元素资源句柄将被添加到元素.
func X创建列表(元素x坐标, 元素y坐标, 宽度, 高度 int32, 父窗口句柄 int) *X结构_列表 {
	p := &X结构_列表{}
	p.X设置句柄(xc.X列表_创建(元素x坐标, 元素y坐标, 宽度, 高度, 父窗口句柄))
	return p
}

// 列表_创建Ex, 创建列表元素, 使用内置项模板, 自动创建数据适配器.
//
// x: 元素x坐标.
//
// y: 元素y坐标.
//
// cx: 宽度.
//
// cy: 高度.
//
// hParent: 父是窗口资源句柄或UI元素资源句柄. 如果是窗口资源句柄将被添加到窗口, 如果是元素资源句柄将被添加到元素.
//
// col_extend_count: 列数量. 例如: 内置模板是1列, 如果数据有5列, 那么此参数填5.
func X创建列表Ex(元素x坐标, 元素y坐标, 宽度, 高度 int32, 父窗口句柄, 列数量 int32) *X结构_列表 {
	p := &X结构_列表{}
	p.X设置句柄(xc.X列表_创建Ex(元素x坐标, 元素y坐标, 宽度, 高度, 父窗口句柄, 列数量))
	return p
}

// 从句柄创建对象.
func X创建列表并按句柄(句柄 int) *X结构_列表 {
	p := &X结构_列表{}
	p.X设置句柄(句柄)
	return p
}

// 从name创建对象, 失败返回nil.
func X创建列表并按名称(名称 string) *X结构_列表 {
	handle := xc.X取对象并按名称(名称)
	if handle > 0 {
		p := &X结构_列表{}
		p.X设置句柄(handle)
		return p
	}
	return nil
}

// 从UID创建对象, 失败返回nil.
func X创建列表并按UID(UID int32) *X结构_列表 {
	handle := xc.X取对象并按UID(UID)
	if handle > 0 {
		p := &X结构_列表{}
		p.X设置句柄(handle)
		return p
	}
	return nil
}

// 从UID名称创建对象, 失败返回nil.
func X创建列表并按UID名称(名称 string) *X结构_列表 {
	handle := xc.X取对象并按UID名称(名称)
	if handle > 0 {
		p := &X结构_列表{}
		p.X设置句柄(handle)
		return p
	}
	return nil
}

// 列表_增加列, 返回位置索引.
//
// width: 列宽度.
func (l *X结构_列表) X增加列(列宽度 int32) int32 {
	return xc.X列表_增加列(l.X句柄, 列宽度)
}

// 列表_插入列, 返回插入位置索引.
//
// width: 列宽度.
//
// iItem: 插入位置索引.
func (l *X结构_列表) X插入列(列宽度, 插入位置索引 int32) int32 {
	return xc.X列表_插入列(l.X句柄, 列宽度, 插入位置索引)
}

// 列表_启用多选, 启用或关闭多选功能.
//
// bEnable: 是否启用.
func (l *X结构_列表) X启用多选(是否启用 bool) *X结构_列表 {
	xc.X列表_启用多选(l.X句柄, 是否启用)
	return l
}

// 列表_启用拖动更改列宽, 启用拖动改变列宽度.
//
// bEnable: 是否启用.
func (l *X结构_列表) X启用拖动更改列宽(是否启用 bool) *X结构_列表 {
	xc.X列表_启用拖动更改列宽(l.X句柄, 是否启用)
	return l
}

// 列表_启用垂直滚动条顶部对齐.
//
// bTop: 是否启用.
func (l *X结构_列表) X启用垂直滚动条顶部对齐(是否启用 bool) *X结构_列表 {
	xc.X列表_启用垂直滚动条顶部对齐(l.X句柄, 是否启用)
	return l
}

// 列表_启用行背景铺满.
//
// bFull: 是否启用.
func (l *X结构_列表) X启用行背景铺满(是否启用 bool) *X结构_列表 {
	xc.X列表_启用行背景铺满(l.X句柄, 是否启用)
	return l
}

// 列表_启用固定行高.
//
// bEnable: 是否启用.
func (l *X结构_列表) X启用固定行高(是否启用 bool) *X结构_列表 {
	xc.X列表_启用固定行高(l.X句柄, 是否启用)
	return l
}

// 列表_启用模板复用.
//
// bEnable: 是否启用.
func (l *X结构_列表) X启用模板复用(是否启用 bool) *X结构_列表 {
	xc.X列表_启用模板复用(l.X句柄, 是否启用)
	return l
}

// 列表_启用虚表.
//
// bEnable: 是否启用.
func (l *X结构_列表) X启用虚表(是否启用 bool) *X结构_列表 {
	xc.X列表_启用虚表(l.X句柄, 是否启用)
	return l
}

// 列表_置虚表行数.
//
// nRowCount: 行数.
func (l *X结构_列表) X设置虚表行数(行数 int32) *X结构_列表 {
	xc.X列表_设置虚表行数(l.X句柄, 行数)
	return l
}

// 列表_置排序, 设置排序属性.
//
// iColumn: 列索引.
//
// iColumnAdapter: 需要排序的数据在数据适配器中的列索引.
//
// bEnable: 是否启用排序功能.
func (l *X结构_列表) X设置排序(列索引 int32, 数据适配器中列索引 int32, 启用排序 bool) *X结构_列表 {
	xc.X列表_设置排序(l.X句柄, 列索引, 数据适配器中列索引, 启用排序)
	return l
}

// 列表_置行背景绘制标志. 设置是否绘制指定状态下行的背景.
//
// nFlags: 标志位, xcc.List_DrawItemBk_Flag_.
func (l *X结构_列表) X设置行背景绘制标志(标志位 xcc.X项背景绘制标识) *X结构_列表 {
	xc.X列表_设置行背景绘制标志(l.X句柄, 标志位)
	return l
}

// 列表_置列宽.
//
// iItem: 列索引.
//
// width: 宽度.
func (l *X结构_列表) X设置列宽(列索引, 宽度 int32) *X结构_列表 {
	xc.X列表_设置列宽(l.X句柄, 列索引, 宽度)
	return l
}

// 列表_置列最小宽度.
//
// iItem: 列索引.
//
// width: 宽度.
func (l *X结构_列表) X设置列最小宽度(列索引, 宽度 int32) *X结构_列表 {
	xc.X列表_设置列最小宽度(l.X句柄, 列索引, 宽度)
	return l
}

// 列表_置列宽度固定.
//
// iColumn: 列索引.
//
// bFixed: 是否固定宽度.
func (l *X结构_列表) X设置列宽度固定(列索引 int32, 固定宽度 bool) *X结构_列表 {
	xc.X列表_设置列宽度固定(l.X句柄, 列索引, 固定宽度)
	return l
}

// 列表_取列宽度.
//
// iColumn: 列索引.
func (l *X结构_列表) X取列宽度(列索引 int32) int32 {
	return xc.X列表_取列宽度(l.X句柄, 列索引)
}

// 列表_取列数量.
func (l *X结构_列表) X取列数量() int32 {
	return xc.X列表_取列数量(l.X句柄)
}

// 列表_置项数据, 设置项用户数据.
//
// iItem: 项索引.
//
// iSubItem: 子项索引.
//
// data: 用户数据.
func (l *X结构_列表) X设置项数据(项索引, 子项索引 int32, 用户数据 int) bool {
	return xc.X列表_设置项数据(l.X句柄, 项索引, 子项索引, 用户数据)
}

// 列表_取项数据, 获取项用户数据.
//
// iItem: 项索引.
//
// iSubItem: 子项索引.
func (l *X结构_列表) X取项数据(项索引, 子项索引 int32) int {
	return xc.X列表_取项数据(l.X句柄, 项索引, 子项索引)
}

// 列表_置选择行.
//
// iRow: 行索引.
func (l *X结构_列表) X设置选择行(行索引 int32) bool {
	return xc.X列表_设置选择行(l.X句柄, 行索引)
}

// 列表_取选择行, 返回行索引.
func (l *X结构_列表) X取选择行() int32 {
	return xc.X列表_取选择行(l.X句柄)
}

// 列表_取选择行数量, 获取选择行数量.
func (l *X结构_列表) X取选择行数量() int32 {
	return xc.X列表_取选择行数量(l.X句柄)
}

// 列表_添加选择行.
//
// iRow: 行索引.
func (l *X结构_列表) X添加选择行(行索引 int32) bool {
	return xc.X列表_添加选择行(l.X句柄, 行索引)
}

// 列表_置选择全部, 选择全部行.
func (l *X结构_列表) X设置选择全部() *X结构_列表 {
	xc.X列表_设置选择全部(l.X句柄)
	return l
}

// 列表_取全部选择, 获取全部选择的行, 返回行数量.
//
// pArray: 接收行索引数组.
//
// nArraySize: 数组大小.
func (l *X结构_列表) X取全部选择(返回行索引 *[]int32, 数组大小 int32) int32 {
	return xc.X列表_取全部选择(l.X句柄, 返回行索引, 数组大小)
}

// 列表_显示指定行, 滚动视图让指定行可见.
//
// iRow: 行索引.
func (l *X结构_列表) X显示指定行(行索引 int32) *X结构_列表 {
	xc.X显示指定行(l.X句柄, 行索引)
	return l
}

// 列表_取消选择行, 取消选择指定行.
//
// iRow: 行索引.
func (l *X结构_列表) X取消选择行(行索引 int32) bool {
	return xc.X列表_取消选择行(l.X句柄, 行索引)
}

// 列表_取消全部选择项, 取消选择所有项(这里的项可以理解为行).
func (l *X结构_列表) X取消全部选择项() *X结构_列表 {
	xc.X列表_取消全部选择项(l.X句柄)
	return l
}

// 列表_取列表头, 获取列表头元素, 返回列表头元素句柄.
func (l *X结构_列表) X取列表头() int {
	return xc.X列表_取列表头(l.X句柄)
}

// 列表_删除列.
//
// iItem: 项索引.
func (l *X结构_列表) X删除列(项索引 int32) bool {
	return xc.X列表_删除列(l.X句柄, 项索引)
}

// 列表_删除全部列, 删除所有的列, 仅删除List的, 数据适配器的列不变.
func (l *X结构_列表) X删除全部列() *X结构_列表 {
	xc.X列表_删除全部列(l.X句柄)
	return l
}

// 列表_绑定数据适配器.
//
// hAdapter: 数据适配器句柄 XAdTable.
func (l *X结构_列表) X绑定数据适配器(数据适配器句柄 int) *X结构_列表 {
	xc.X列表_绑定数据适配器(l.X句柄, 数据适配器句柄)
	return l
}

// 列表_列表头绑定数据适配器.
//
// hAdapter: 数据适配器句柄 XAdMap.
func (l *X结构_列表) X列表头绑定数据适配器(数据适配器句柄 int) *X结构_列表 {
	xc.X列表_列表头绑定数据适配器(l.X句柄, 数据适配器句柄)
	return l
}

// 列表_创建数据适配器, 创建数据适配器，根据绑定的项模板初始化数据适配器的列, 返回适配器句柄.
//
// colExtend_count:	列延伸-预计列表总列数, 默认值0; 限制最大延伸范围, 避免超出范围, 增加不必要的字段.
func (l *X结构_列表) X创建数据适配器(预计列表总列数 int32) int {
	return xc.X列表_创建数据适配器(l.X句柄, 预计列表总列数)
}

// 列表_列表头创建数据适配器, 创建数据适配器，根据绑定的项模板初始化数据适配器的列, 返回适配器句柄.
func (l *X结构_列表) X创建列表头数据适配器() int {
	return xc.X列表_列表头创建数据适配器(l.X句柄)
}

// 列表_取数据适配器, 返回数据适配器句柄.
func (l *X结构_列表) X取数据适配器() int {
	return xc.X列表_取数据适配器(l.X句柄)
}

// 列表_列表头获取数据适配器, 获取列表头数据适配器句柄.
func (l *X结构_列表) X取列表头数据适配器() int {
	return xc.X列表_列表头获取数据适配器(l.X句柄)
}

// 列表_置项模板文件, 设置项布局模板文件.
//
// pXmlFile: 文件名.
func (l *X结构_列表) X设置项模板文件(文件名 string) bool {
	return xc.X列表_设置项模板文件(l.X句柄, 文件名)
}

// 列表_置项模板从字符串, 设置项布局模板文件.
//
// pStringXML: 字符串.
func (l *X结构_列表) X设置项模板从文本(xml文本 string) bool {
	return xc.X列表_设置项模板从文本(l.X句柄, xml文本)
}

// 列表_置项模板, 设置列表项模板.
//
// hTemp: 模板句柄.
func (l *X结构_列表) X设置项模板(模板句柄 int) bool {
	return xc.X列表_设置项模板(l.X句柄, 模板句柄)
}

// 列表_取项模板对象, 通过模板项ID, 获取实例化模板项ID对应的对象句柄.
//
// iItem: 项索引.
//
// iSubItem: 子项索引.
//
// nTempItemID: 模板项itemID.
func (l *X结构_列表) X取项模板对象(项索引, 子项索引 int32, 模板项itemID int32) int {
	return xc.X列表_取项模板对象(l.X句柄, 项索引, 子项索引, 模板项itemID)
}

// 列表_取对象所在行. 获取当前对象所在模板实例, 属于列表中哪一行. 成功返回行索引, 否则返回 xcc.XC_ID_ERROR.
//
// hXCGUI: 对象句柄, UI元素句柄或形状对象句柄.
func (l *X结构_列表) X取对象所在行(对象句柄 int) int32 {
	return xc.X列表_取对象所在行(l.X句柄, 对象句柄)
}

// 列表_取列表头模板对象, 列表头, 通过模板项ID, 获取实例化模板项ID对应的对象句柄.
//
// iItem: 列表头项ID.
//
// nTempItemID: 模板项ID.
func (l *X结构_列表) X取列表头模板对象(列表头项ID int32, 模板项ID int32) int {
	return xc.X列表_取列表头模板对象(l.X句柄, 列表头项ID, 模板项ID)
}

// 列表_取列表头对象所在列. 列表头, 获取当前对象所在模板实例, 属于列表头中哪一个列. 成功返回列索引, 否则返回 xcc.XC_ID_ERROR.
//
// hXCGUI: 对象句柄.
func (l *X结构_列表) X取列表头对象所在列(对象句柄 int) int32 {
	return xc.X列表_取列表头对象所在列(l.X句柄, 对象句柄)
}

// 列表_置列表头高度.
//
// height: 高度.
func (l *X结构_列表) X设置列表头高度(高度 int32) *X结构_列表 {
	xc.X列表_设置列表头高度(l.X句柄, 高度)
	return l
}

// 列表_取列表头高度.
func (l *X结构_列表) X取列表头高度() int32 {
	return xc.X列表_取列表头高度(l.X句柄)
}

// 列表_取可视行范围.
//
// piStart: 开始行索引.
//
// piEnd: 结束行索引.
func (l *X结构_列表) X取可视行范围(开始行索引 *int32, 结束行索引 *int32) *X结构_列表 {
	xc.X列表_取可视行范围(l.X句柄, 开始行索引, 结束行索引)
	return l
}

// 列表_置行默认高度.
//
// nHeight: 高度.
//
// nSelHeight: 选中时高度.
func (l *X结构_列表) X设置行默认高度(高度 int32, 选中时高度 int32) *X结构_列表 {
	xc.X列表_设置行默认高度(l.X句柄, 高度, 选中时高度)
	return l
}

// 列表_取行默认高度.
//
// pHeight: 高度.
//
// pSelHeight: 选中时高度.
func (l *X结构_列表) X取行默认高度(返回高度 *int32, 返回选中时高度 *int32) *X结构_列表 {
	xc.X列表_取行默认高度(l.X句柄, 返回高度, 返回选中时高度)
	return l
}

// 列表_置行间距.
//
// nSpace: 行间距大小.
func (l *X结构_列表) X设置行间距(行间距大小 int32) *X结构_列表 {
	xc.X列表_设置行间距(l.X句柄, 行间距大小)
	return l
}

// 列表_取行间距.
func (l *X结构_列表) X取行间距() int32 {
	return xc.X列表_取行间距(l.X句柄)
}

// 列表_置锁定列左侧, 锁定列, 设置左侧锁定列分界列索引.
//
// iColumn: 列索引, -1代表不锁定.
func (l *X结构_列表) X设置锁定列左侧(列索引 int32) *X结构_列表 {
	xc.X列表_设置锁定列左侧(l.X句柄, 列索引)
	return l
}

// 列表_置锁定列右侧.
//
// iColumn: 列索引, -1代表不锁定. 暂时只支持锁定末尾列.
func (l *X结构_列表) X设置锁定列右侧(列索引 int32) *X结构_列表 {
	xc.X列表_设置锁定列右侧(l.X句柄, 列索引)
	return l
}

// 列表_置锁定行底部, 设置是否锁定末尾行.
//
// bLock: 是否锁定.
func (l *X结构_列表) X设置锁定行底部(是否锁定 bool) *X结构_列表 {
	xc.X列表_设置锁定行底部(l.X句柄, 是否锁定)
	return l
}

// 列表_置锁定行底部重叠.
//
// bOverlap: 是否重叠.
func (l *X结构_列表) X设置锁定行底部重叠(是否重叠 bool) *X结构_列表 {
	xc.X列表_设置锁定行底部重叠(l.X句柄, 是否重叠)
	return l
}

// 列表_测试点击项, 检测坐标点所在项.
//
// pPt: 坐标点.
//
// piItem: 项索引.
//
// piSubItem: 子项索引.
func (l *X结构_列表) X测试点击项(坐标点 *xc.X结构_坐标, 行索引 *int32, 列索引 *int32) bool {
	return xc.X列表_测试点击项(l.X句柄, 坐标点, 行索引, 列索引)
}

// 列表_测试点击项扩展, 检查坐标点所在项, 自动添加滚动视图偏移量.
//
// pPt: 坐标点.
//
// piItem: 项索引.
//
// piSubItem: 子项索引.
func (l *X结构_列表) X测试点击项EX(坐标点 *xc.X结构_坐标, 行索引 *int32, 列索引 *int32) bool {
	return xc.X列表_测试点击项EX(l.X句柄, 坐标点, 行索引, 列索引)
}

// 列表_刷新项数据.
func (l *X结构_列表) X刷新项数据() *X结构_列表 {
	xc.X列表_刷新项数据(l.X句柄)
	return l
}

// 列表_刷新指定行. 修改数据后, 刷新指定行模板, 以便更新数据到模板(如果当前行可见).
//
// iRow: 行索引.
func (l *X结构_列表) X刷新指定行(行索引 int32) *X结构_列表 {
	xc.X列表_刷新指定行(l.X句柄, 行索引)
	return l
}

// 列表_添加列文本.
//
// nWidth: 列宽.
//
// pName: 模板里绑定的name名. 在List内部存在有默认模板, name名是从name1到namen.
//
// pText: 文本.
func (l *X结构_列表) X添加列文本(列宽 int32, 名称 string, 文本 string) int32 {
	return xc.X列表_添加列文本(l.X句柄, 列宽, 名称, 文本)
}

// 列表_添加列图片.
//
// nWidth: 列宽.
//
// pName: 模板里绑定的name名. 在List内部存在有默认模板, name名是从name1到namen.
//
// hImage: 图片句柄.
func (l *X结构_列表) X添加列图片(列宽 int32, 名称 string, 图片句柄 int) int32 {
	return xc.X列表_添加列图片(l.X句柄, 列宽, 名称, 图片句柄)
}

// 列表_添加行文本.
//
// pText:.
func (l *X结构_列表) X添加行文本(文本 string) int32 {
	return xc.X列表_添加行文本(l.X句柄, 文本)
}

// 列表_添加行文本扩展.
//
// pName:.
//
// pText:.
func (l *X结构_列表) X添加行文本EX(名称 string, 文本 string) int32 {
	return xc.X列表_添加行文本EX(l.X句柄, 名称, 文本)
}

// 列表_添加行图片.
//
// hImage:.
func (l *X结构_列表) X添加行图片(图片句柄 int) int32 {
	return xc.X列表_添加行图片(l.X句柄, 图片句柄)
}

// 列表_添加行图片扩展.
//
// pName:.
//
// hImage:.
func (l *X结构_列表) X添加行图片EX(名称 string, 图片句柄 int) int32 {
	return xc.X列表_添加行图片EX(l.X句柄, 名称, 图片句柄)
}

// 列表_插入行文本.
//
// iRow:.
//
// pValue:.
func (l *X结构_列表) X插入行文本(行索引 int32, 文本 string) int32 {
	return xc.X列表_插入行文本(l.X句柄, 行索引, 文本)
}

// 列表_插入行文本扩展.
//
// iRow:.
//
// pName:.
//
// pValue:.
func (l *X结构_列表) X插入行文本EX(行索引 int32, 名称 string, 文本 string) int32 {
	return xc.X插入行文本EX(l.X句柄, 行索引, 名称, 文本)
}

// 列表_插入行图片.
//
// iRow:.
//
// hImage:.
func (l *X结构_列表) X列表_插入行图片(行索引 int32, 图片句柄 int) int32 {
	return xc.X列表_插入行图片(l.X句柄, 行索引, 图片句柄)
}

// 列表_插入行图片扩展.
//
// iRow:.
//
// pName:.
//
// hImage:.
func (l *X结构_列表) X列表_插入行图片扩展(行索引 int32, 名称 string, 图片句柄 int) int32 {
	return xc.X列表_插入行图片扩展(l.X句柄, 行索引, 名称, 图片句柄)
}

// 列表_置项文本.
//
// iItem:.
//
// iColumn:.
//
// pText:.
func (l *X结构_列表) X设置项文本(项, 列 int32, 文本 string) bool {
	return xc.X列表_设置项文本(l.X句柄, 项, 列, 文本)
}

// 列表_置项文本扩展.
//
// iItem:.
//
// pName:.
//
// pText:.
func (l *X结构_列表) X设置项文本EX(项 int32, 名称 string, 文本 string) bool {
	return xc.X列表_设置项文本EX(l.X句柄, 项, 名称, 文本)
}

// 列表_置项图片.
//
// iItem:.
//
// iColumn:.
//
// hImage:.
func (l *X结构_列表) X设置项图片(项, 列 int32, 图片 int) bool {
	return xc.X列表_设置项图片(l.X句柄, 项, 列, 图片)
}

// 列表_置项图片扩展.
//
// iItem:.
//
// pName:.
//
// hImage:.
func (l *X结构_列表) X设置项图片EX(项 int32, 名称 string, 图片 int) bool {
	return xc.X列表_设置项图片EX(l.X句柄, 项, 名称, 图片)
}

// 列表_置项指数值.
//
// iItem:.
//
// iColumn:.
//
// nValue:.
func (l *X结构_列表) X设置项指数值(项, 列 int32, 值 int32) bool {
	return xc.X列表_设置项指数值(l.X句柄, 项, 列, 值)
}

// 列表_置项整数值扩展.
//
// iItem:.
//
// pName:.
//
// nValue:.
func (l *X结构_列表) X设置项整数值EX(项 int32, 名称 string, 值 int32) bool {
	return xc.X列表_设置项整数值EX(l.X句柄, 项, 名称, 值)
}

// 列表_置项浮点值.
//
// iItem:.
//
// iColumn:.
//
// fFloat:.
func (l *X结构_列表) X设置项浮点值(项 int32, 列 int32, 值 float32) bool {
	return xc.X列表_设置项浮点值(l.X句柄, 项, 列, 值)
}

// 列表_置项浮点值扩展.
//
// iItem:.
//
// pName:.
//
// fFloat:.
func (l *X结构_列表) X设置项浮点值EX(项 int32, 名称 string, 值 float32) bool {
	return xc.X列表_设置项浮点值EX(l.X句柄, 项, 名称, 值)
}

// 列表_取项文本.
//
// iItem:.
//
// iColumn:.
func (l *X结构_列表) X取项文本(项 int32, 列 int32) string {
	return xc.X列表_取项文本(l.X句柄, 项, 列)
}

// 列表_取项文本扩展.
//
// iItem:.
//
// pName:.
func (l *X结构_列表) X取项文本EX(项 int32, 名称 string) string {
	return xc.X列表_取项文本EX(l.X句柄, 项, 名称)
}

// 列表_取项图片. 返回图片句柄.
//
// iItem:.
//
// iColumn:.
func (l *X结构_列表) X取项图片(项 int32, 列 int32) int {
	return xc.X列表_取项图片(l.X句柄, 项, 列)
}

// 列表_取项图片扩展. 返回图片句柄.
//
// iItem:.
//
// pName:.
func (l *X结构_列表) X取项图片EX(项 int32, 名称 string) int {
	return xc.X列表_取项图片EX(l.X句柄, 项, 名称)
}

// 列表_取项整数值.
//
// iItem:.
//
// iColumn:.
//
// pOutValue:.
func (l *X结构_列表) X取项整数值(项, 列 int32, 值指针 *int32) bool {
	return xc.X列表_取项整数值(l.X句柄, 项, 列, 值指针)
}

// 列表_取项整数值扩展.
//
// iItem:.
//
// pName:.
//
// pOutValue:.
func (l *X结构_列表) X取项整数值EX(项 int32, 文本 string, 值指针 *int32) bool {
	return xc.X列表_取项整数值EX(l.X句柄, 项, 文本, 值指针)
}

// 列表_取项浮点值.
//
// iItem:.
//
// iColumn:.
//
// pOutValue:.
func (l *X结构_列表) X取项浮点值(项, 列 int32, 值指针 *float32) bool {
	return xc.X列表_取项浮点值(l.X句柄, 项, 列, 值指针)
}

// 列表_取项浮点值扩展.
//
// iItem:.
//
// pName:.
//
// pOutValue:.
func (l *X结构_列表) X取项浮点值EX(项 int32, 名称 string, 值指针 *float32) bool {
	return xc.X列表_取项浮点值EX(l.X句柄, 项, 名称, 值指针)
}

// 列表_删除行.
//
// iRow:.
func (l *X结构_列表) X删除行(行索引 int32) bool {
	return xc.X列表_删除行(l.X句柄, 行索引)
}

// 列表_删除行扩展.
//
// iRow:.
//
// nCount:.
func (l *X结构_列表) X删除行EX(行索引 int32, 删除数量 int32) bool {
	return xc.X列表_删除行EX(l.X句柄, 行索引, 删除数量)
}

// 列表_删除行全部.
func (l *X结构_列表) X删除行全部() *X结构_列表 {
	xc.X列表_删除行全部(l.X句柄)
	return l
}

// 列表_删除列全部AD.
func (l *X结构_列表) X删除列全部AD() *X结构_列表 {
	xc.X列表_删除列全部AD(l.X句柄)
	return l
}

// 列表_取项数量AD.
func (l *X结构_列表) X取项数量AD() int32 {
	return xc.X列表_取项数量AD(l.X句柄)
}

// 列表_取列数量AD.
func (l *X结构_列表) X取列数量AD() int32 {
	return xc.X列表_取列数量AD(l.X句柄)
}

// 列表_置分割线颜色.
//
// color: xc.RGBA 颜色值.
func (l *X结构_列表) X设置分割线颜色(ABGR颜色值 int) *X结构_列表 {
	xc.X列表_设置分割线颜色(l.X句柄, ABGR颜色值)
	return l
}

// 列表_置行高度.
//
// iRow: 行索引.
//
// nHeight: 高度.
//
// nSelHeight: 选中时高度.
func (l *X结构_列表) X设置行高(行索引 int32, 高度, 选中时高度 int32) *X结构_列表 {
	xc.X列表_设置行高(l.X句柄, 行索引, 高度, 选中时高度)
	return l
}

// 列表_取行高度.
//
// iRow: 行索引.
//
// pHeight: 高度.
//
// pSelHeight: 选中时高度.
func (l *X结构_列表) X取行高度(行索引 int32, 返回高度, 返回选中时高度 *int32) *X结构_列表 {
	xc.X列表_取行高度(l.X句柄, 行索引, 返回高度, 返回选中时高度)
	return l
}

// 列表_置拖动矩形颜色.
//
// color: xc.RGBA 颜色值.
//
// width: 线宽度.
func (l *X结构_列表) X设置拖动矩形颜色(ABGR颜色值 int, 线宽度 int32) *X结构_列表 {
	xc.X列表_设置拖动矩形颜色(l.X句柄, ABGR颜色值, 线宽度)
	return l
}

// 列表_取项模板. 返回列表项模板句柄.
func (l *X结构_列表) X取项模板() int {
	return xc.X列表_取项模板(l.X句柄)
}

// 列表_取项模板列表头. 返回列表头项模板句柄.
func (l *X结构_列表) X取项模板列表头() int {
	return xc.X列表_取项模板列表头(l.X句柄)
}

// 列表_刷新项数据列表头.
func (l *X结构_列表) X刷新项数据列表头() *X结构_列表 {
	xc.X列表_刷新项数据列表头(l.X句柄)
	return l
}

// 列表_置项模板从内存.
//
// data: 模板数据.
func (l *X结构_列表) X设置项模板从内存(模板数据 []byte) bool {
	return xc.X列表_设置项模板从内存(l.X句柄, 模板数据)
}

// 列表_置项模板从资源ZIP. 从RC资源ZIP加载.
//
// id: RC资源ID.
//
// pFileName: 项模板文件名.
//
// pPassword: zip密码.
//
// hModule: 模块句柄, 可填0.
func (l *X结构_列表) X设置项模板并按资源zip(RC资源ID int32, 项模板文件名 string, zip密码 string, 模块句柄 uintptr) bool {
	return xc.X列表_设置项模板从资源zip(l.X句柄, RC资源ID, 项模板文件名, zip密码, 模块句柄)
}

// 列表_添加列文本2, 返回列索引. 简化版本.
//
// nWidth: 列宽度.
//
// pText: 标题文本.
func (l *X结构_列表) X添加列文本2(列宽度 int32, 文本 string) int32 {
	return xc.X列表_添加列文本2(l.X句柄, 列宽度, 文本)
}

// 列表_添加列图片2, 返回列索引. 简化版本.
//
// nWidth: 列宽度.
//
// hImage: 图片句柄.
func (l *X结构_列表) X列表_添加列图片2(列宽度 int32, 图片句柄 int) int32 {
	return xc.X列表_添加列图片2(l.X句柄, 列宽度, 图片句柄)
}

// 列表_创建数据适配器2. 创建数据适配器，根据绑定的项模板初始化数据适配器的列(字段名); 数据适配器存储数据, UI对象根据绑定的字段名显示数据适配器中对应的数据; 此接口是简化接口, 合并了 xc.XList_CreateAdapter() 和 xc.XList_CreateAdapterHeader() 接口;
//
// col_extend_count: 列延伸-预计列表总列数, 默认值0; 限制最大延伸范围, 避免超出范围, 增加不必要的字段. 例如默认模板是1列, 但是数据有5列,那么列延伸填5.
func (l *X结构_列表) X创建数据适配器2(预计列表总列数 int32) bool {
	return xc.X列表_创建数据适配器2(l.X句柄, 预计列表总列数)
}

// ------------------------- 事件 ------------------------- //

// 列表元素-项模板创建事件,模板复用机制需先启用;替换模板无效判断nFlag,因为内部会检查模板是否改变,不用担心重复.
//
// nFlag  0:状态改变; 1:新模板实例; 2:旧模板复用
type X事件_列表_项模板创建 func(pItem *xc.X结构_列表项, nFlag int32, pbHandled *bool) int

// 列表元素-项模板创建事件,模板复用机制需先启用;替换模板无效判断nFlag,因为内部会检查模板是否改变,不用担心重复.
//
// nFlag  0:状态改变; 1:新模板实例; 2:旧模板复用
type X事件_列表_项模板创建1 func(hEle int, pItem *xc.X结构_列表项, nFlag int32, pbHandled *bool) int

// 列表元素-项模板创建完成事件,模板复用机制需先启用;不管是新建还是复用,都需要更新数据, 当为复用时不要注册事件以免重复注册.
//
// nFlag  0:状态改变(复用); 1:新模板实例; 2:旧模板复用
type X事件_列表_项模板创建完成 func(pItem *xc.X结构_列表项, nFlag int32, pbHandled *bool) int

// 列表元素-项模板创建完成事件,模板复用机制需先启用;不管是新建还是复用,都需要更新数据, 当为复用时不要注册事件以免重复注册.
//
// nFlag  0:状态改变(复用); 1:新模板实例; 2:旧模板复用
type X事件_列表_项模板创建完成1 func(hEle int, pItem *xc.X结构_列表项, nFlag int32, pbHandled *bool) int

// 列表元素,项模板销毁.
//
// nFlag   0:正常销毁;  1:移动到缓存(不会被销毁,临时缓存备用,当需要时被复用)
type X事件_列表_项模板销毁 func(pItem *xc.X结构_列表项, nFlag int32, pbHandled *bool) int

// 列表元素,项模板销毁.
//
// nFlag   0:正常销毁;  1:移动到缓存(不会被销毁,临时缓存备用,当需要时被复用)
type X事件_列表_项模板销毁1 func(hEle int, pItem *xc.X结构_列表项, nFlag int32, pbHandled *bool) int
type X弃用_事件_列表_项模板调整坐标 func(pItem *xc.X结构_列表项, pbHandled *bool) int                          // 列表元素,项模板调整坐标. 已停用.
type X弃用_事件_列表_项模板调整坐标1 func(hEle int, pItem *xc.X结构_列表项, pbHandled *bool) int               // 列表元素,项模板调整坐标. 已停用.
type X事件_列表_绘制项 func(hDraw int, pItem *xc.X结构_列表项, pbHandled *bool) int                             // 列表元素,绘制项.
type X事件_列表_绘制项1 func(hEle int, hDraw int, pItem *xc.X结构_列表项, pbHandled *bool) int                  // 列表元素,绘制项.
type X事件_列表_项选择 func(iItem int32, pbHandled *bool) int                                                   // 列表元素,项选择事件.
type X事件_列表_项选择1 func(hEle int, iItem int32, pbHandled *bool) int                                        // 列表元素,项选择事件.
type X事件_列表_列表元素绘制列表头项 func(hDraw int, pItem *xc.X结构_列表头项, pbHandled *bool) int               // 列表元素绘制列表头项.
type X事件_列表_列表元素绘制列表头项1 func(hEle int, hDraw int, pItem *xc.X结构_列表头项, pbHandled *bool) int    // 列表元素绘制列表头项.
type X事件_列表_列表头项点击 func(iItem int32, pbHandled *bool) int                                             // 列表元素,列表头项点击事件.
type X事件_列表_列表头项点击1 func(hEle int, iItem int32, pbHandled *bool) int                                  // 列表元素,列表头项点击事件.
type X事件_列表_列表头项宽度改变 func(iItem int32, nWidth int32, pbHandled *bool) int                        // 列表元素,列表头项宽度改变事件.
type X事件_列表_列表头项宽度改变1 func(hEle int, iItem int32, nWidth int32, pbHandled *bool) int             // 列表元素,列表头项宽度改变事件.
type X事件_列表_列表头项模板创建 func(pItem *xc.X结构_列表头项, pbHandled *bool) int                       // 列表元素,列表头项模板创建.
type X事件_列表_列表头项模板创建1 func(hEle int, pItem *xc.X结构_列表头项, pbHandled *bool) int            // 列表元素,列表头项模板创建.
type X事件_列表_列表头项模板创建完成 func(pItem *xc.X结构_列表头项, pbHandled *bool) int                   // 列表元素,列表头项模板创建完成事件.
type X事件_列表_列表头项模板创建完成1 func(hEle int, pItem *xc.X结构_列表头项, pbHandled *bool) int        // 列表元素,列表头项模板创建完成事件.
type X事件_列表_列表头项模板销毁 func(pItem *xc.X结构_列表头项, pbHandled *bool) int                      // 列表元素,列表头项模板销毁.
type X事件_列表_列表头项模板销毁1 func(hEle int, pItem *xc.X结构_列表头项, pbHandled *bool) int           // 列表元素,列表头项模板销毁.
type X弃用_事件_列表_列表头项模板调整坐标 func(pItem *xc.X结构_列表头项, pbHandled *bool) int            // 列表元素,列表头项模板调整坐标. 已停用.
type X弃用_事件_列表_列表头项模板调整坐标1 func(hEle int, pItem *xc.X结构_列表头项, pbHandled *bool) int // 列表元素,列表头项模板调整坐标. 已停用.

// 列表元素-项模板创建事件,模板复用机制需先启用;替换模板无效判断nFlag,因为内部会检查模板是否改变,不用担心重复.
//
// nFlag  0:状态改变; 1:新模板实例; 2:旧模板复用
func (l *X结构_列表) X事件_项模板创建(回调函数 X事件_列表_项模板创建) bool {
	return xc.X元素_注册事件C(l.X句柄, xcc.X元素事件_列表_项模板创建, 回调函数)
}

// 列表元素-项模板创建事件,模板复用机制需先启用;替换模板无效判断nFlag,因为内部会检查模板是否改变,不用担心重复.
//
// nFlag  0:状态改变; 1:新模板实例; 2:旧模板复用
func (l *X结构_列表) X事件_项模板创建1(回调函数 X事件_列表_项模板创建1) bool {
	return xc.X元素_注册事件C1(l.X句柄, xcc.X元素事件_列表_项模板创建, 回调函数)
}

// 列表元素-项模板创建完成事件,模板复用机制需先启用;不管是新建还是复用,都需要更新数据, 当为复用时不要注册事件以免重复注册.
//
// nFlag  0:状态改变(复用); 1:新模板实例; 2:旧模板复用
func (l *X结构_列表) X事件_项模板创建完成(回调函数 X事件_列表_项模板创建完成) bool {
	return xc.X元素_注册事件C(l.X句柄, xcc.X元素事件_列表_项模板创建完成, 回调函数)
}

// 列表元素-项模板创建完成事件,模板复用机制需先启用;不管是新建还是复用,都需要更新数据, 当为复用时不要注册事件以免重复注册.
//
// nFlag  0:状态改变(复用); 1:新模板实例; 2:旧模板复用
func (l *X结构_列表) X事件_项模板创建完成1(回调函数 X事件_列表_项模板创建完成1) bool {
	return xc.X元素_注册事件C1(l.X句柄, xcc.X元素事件_列表_项模板创建完成, 回调函数)
}

// 列表元素,项模板销毁.
//
// nFlag   0:正常销毁;  1:移动到缓存(不会被销毁,临时缓存备用,当需要时被复用)
func (l *X结构_列表) X事件_项模板销毁(回调函数 X事件_列表_项模板销毁) bool {
	return xc.X元素_注册事件C(l.X句柄, xcc.X元素事件_列表_项模板销毁, 回调函数)
}

// 列表元素,项模板销毁.
//
// nFlag   0:正常销毁;  1:移动到缓存(不会被销毁,临时缓存备用,当需要时被复用)
func (l *X结构_列表) X事件_项模板销毁1(回调函数 X事件_列表_项模板销毁1) bool {
	return xc.X元素_注册事件C1(l.X句柄, xcc.X元素事件_列表_项模板销毁, 回调函数)
}

// 列表元素,项模板调整坐标. 已停用.
func (l *X结构_列表) X停用_项模板调整坐标(回调函数 X弃用_事件_列表_项模板调整坐标) bool {
	return xc.X元素_注册事件C(l.X句柄, xcc.X元素事件_列表_项模板调整坐标_已停用, 回调函数)
}

// 列表元素,项模板调整坐标. 已停用.
func (l *X结构_列表) X停用_项模板调整坐标1(回调函数 X弃用_事件_列表_项模板调整坐标1) bool {
	return xc.X元素_注册事件C1(l.X句柄, xcc.X元素事件_列表_项模板调整坐标_已停用, 回调函数)
}

// 列表元素,绘制项.
func (l *X结构_列表) X事件_绘制项(回调函数 X事件_列表_绘制项) bool {
	return xc.X元素_注册事件C(l.X句柄, xcc.X元素事件_列表_绘制项, 回调函数)
}

// 列表元素,绘制项.
func (l *X结构_列表) X事件_绘制项1(回调函数 X事件_列表_绘制项1) bool {
	return xc.X元素_注册事件C1(l.X句柄, xcc.X元素事件_列表_绘制项, 回调函数)
}

// 列表元素,项选择事件.
func (l *X结构_列表) X事件_项选择(回调函数 X事件_列表_项选择) bool {
	return xc.X元素_注册事件C(l.X句柄, xcc.X元素事件_列表_项选择, 回调函数)
}

// 列表元素,项选择事件.
func (l *X结构_列表) X事件_项选择1(回调函数 X事件_列表_项选择1) bool {
	return xc.X元素_注册事件C1(l.X句柄, xcc.X元素事件_列表_项选择, 回调函数)
}

// 列表元素绘制列表头项.
func (l *X结构_列表) X事件_列表元素绘制列表头项(回调函数 X事件_列表_列表元素绘制列表头项) bool {
	return xc.X元素_注册事件C(l.X句柄, xcc.X元素事件_列表_绘制列表头项, 回调函数)
}

// 列表元素绘制列表头项.
func (l *X结构_列表) X事件_列表元素绘制列表头项1(回调函数 X事件_列表_列表元素绘制列表头项1) bool {
	return xc.X元素_注册事件C1(l.X句柄, xcc.X元素事件_列表_绘制列表头项, 回调函数)
}

// 列表元素,列表头项点击事件.
func (l *X结构_列表) X事件_列表头项点击(回调函数 X事件_列表_列表头项点击) bool {
	return xc.X元素_注册事件C(l.X句柄, xcc.X元素事件_列表_列表头项点击, 回调函数)
}

// 列表元素,列表头项点击事件.
func (l *X结构_列表) X事件_列表头项点击1(回调函数 X事件_列表_列表头项点击1) bool {
	return xc.X元素_注册事件C1(l.X句柄, xcc.X元素事件_列表_列表头项点击, 回调函数)
}

// 列表元素,列表头项宽度改变事件.
func (l *X结构_列表) X事件_列表头项宽度改变(回调函数 X事件_列表_列表头项宽度改变) bool {
	return xc.X元素_注册事件C(l.X句柄, xcc.X元素事件_列表_列表头项宽度改变, 回调函数)
}

// 列表元素,列表头项宽度改变事件.
func (l *X结构_列表) X事件_列表头项宽度改变1(回调函数 X事件_列表_列表头项宽度改变1) bool {
	return xc.X元素_注册事件C1(l.X句柄, xcc.X元素事件_列表_列表头项宽度改变, 回调函数)
}

// 列表元素,列表头项模板创建.
func (l *X结构_列表) X事件_列表头项模板创建(回调函数 X事件_列表_列表头项模板创建) bool {
	return xc.X元素_注册事件C(l.X句柄, xcc.X元素事件_列表_列表头项模板创建, 回调函数)
}

// 列表元素,列表头项模板创建.
func (l *X结构_列表) X事件_列表头项模板创建1(回调函数 X事件_列表_列表头项模板创建1) bool {
	return xc.X元素_注册事件C1(l.X句柄, xcc.X元素事件_列表_列表头项模板创建, 回调函数)
}

// 列表元素,列表头项模板创建完成事件.
func (l *X结构_列表) X事件_列表头项模板创建完成(回调函数 X事件_列表_列表头项模板创建完成) bool {
	return xc.X元素_注册事件C(l.X句柄, xcc.X元素事件_列表_列表头项模板创建完成, 回调函数)
}

// 列表元素,列表头项模板创建完成事件.
func (l *X结构_列表) X事件_列表头项模板创建完成1(回调函数 X事件_列表_列表头项模板创建完成1) bool {
	return xc.X元素_注册事件C1(l.X句柄, xcc.X元素事件_列表_列表头项模板创建完成, 回调函数)
}

// 列表元素,列表头项模板销毁.
func (l *X结构_列表) X事件_列表头项模板销毁(回调函数 X事件_列表_列表头项模板销毁) bool {
	return xc.X元素_注册事件C(l.X句柄, xcc.X元素事件_列表_列表头项模板销毁, 回调函数)
}

// 列表元素,列表头项模板销毁.
func (l *X结构_列表) X事件_列表头项模板销毁1(回调函数 X事件_列表_列表头项模板销毁1) bool {
	return xc.X元素_注册事件C1(l.X句柄, xcc.X元素事件_列表_列表头项模板销毁, 回调函数)
}

// 列表元素,列表头项模板调整坐标. 已停用.
func (l *X结构_列表) X停用_列表头项模板调整坐标(回调函数 X弃用_事件_列表_列表头项模板调整坐标) bool {
	return xc.X元素_注册事件C(l.X句柄, xcc.X元素事件_列表_列表头项模板调整坐标_已停用, 回调函数)
}

// 列表元素,列表头项模板调整坐标. 已停用.
func (l *X结构_列表) X停用_列表头项模板调整坐标1(回调函数 X弃用_事件_列表_列表头项模板调整坐标1) bool {
	return xc.X元素_注册事件C1(l.X句柄, xcc.X元素事件_列表_列表头项模板调整坐标_已停用, 回调函数)
}

// ------------------------- AddEvent ------------------------- //

// AddEvent_List_Temp_Create 添加列表项模板创建事件. 模板复用机制需先启用; 替换模板无效判断 nFlag, 因为内部会检查模板是否改变, 不用担心重复.
//   - nFlag: 0: 状态改变(复用); 1: 新模板实例; 2: 旧模板复用
//
// pFun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (l *X结构_列表) AddEvent_List_Temp_Create(pFun X事件_列表_项模板创建1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(l.X句柄, xcc.X元素事件_列表_项模板创建, onXE_LIST_TEMP_CREATE, pFun, allowAddingMultiple...)
}

// onXE_LIST_TEMP_CREATE 列表项模板创建事件.
func onXE_LIST_TEMP_CREATE(hEle int, pItem *xc.X结构_列表项, nFlag int32, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hEle, xcc.X元素事件_列表_项模板创建)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_列表_项模板创建1)(hEle, pItem, nFlag, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}

// AddEvent_List_Temp_Create_End 添加列表项模板创建完成事件. 模板复用机制需先启用; 不管是新建还是复用, 都需要更新数据, 当为复用时不要注册事件以免重复注册.
//   - nFlag: 0: 状态改变(复用); 1: 新模板实例; 2: 旧模板复用
//
// pFun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (l *X结构_列表) AddEvent_List_Temp_Create_End(pFun X事件_列表_项模板创建完成1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(l.X句柄, xcc.X元素事件_列表_项模板创建完成, onXE_LIST_TEMP_CREATE_END, pFun, allowAddingMultiple...)
}

// onXE_LIST_TEMP_CREATE_END 列表项模板创建完成事件.
func onXE_LIST_TEMP_CREATE_END(hEle int, pItem *xc.X结构_列表项, nFlag int32, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hEle, xcc.X元素事件_列表_项模板创建完成)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_列表_项模板创建完成1)(hEle, pItem, nFlag, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}

// AddEvent_List_Temp_Destroy 添加列表项模板销毁事件.
//   - nFlag: 0: 正常销毁; 1: 移动到缓存(不会被销毁, 临时缓存备用, 当需要时被复用)
//
// pFun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (l *X结构_列表) AddEvent_List_Temp_Destroy(pFun X事件_列表_项模板销毁1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(l.X句柄, xcc.X元素事件_列表_项模板销毁, onXE_LIST_TEMP_DESTROY, pFun, allowAddingMultiple...)
}

// onXE_LIST_TEMP_DESTROY 列表项模板销毁事件.
func onXE_LIST_TEMP_DESTROY(hEle int, pItem *xc.X结构_列表项, nFlag int32, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hEle, xcc.X元素事件_列表_项模板销毁)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_列表_项模板销毁1)(hEle, pItem, nFlag, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}

// AddEvent_List_Temp_Adjust_Coordinate 添加列表项模板调整坐标事件. 已停用.
//
// pFun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (l *X结构_列表) AddEvent_List_Temp_Adjust_Coordinate(pFun X弃用_事件_列表_项模板调整坐标1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(l.X句柄, xcc.X元素事件_列表_项模板调整坐标_已停用, onXE_LIST_TEMP_ADJUST_COORDINATE, pFun, allowAddingMultiple...)
}

// onXE_LIST_TEMP_ADJUST_COORDINATE 列表项模板调整坐标事件.
func onXE_LIST_TEMP_ADJUST_COORDINATE(hEle int, pItem *xc.X结构_列表项, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hEle, xcc.X元素事件_列表_项模板调整坐标_已停用)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X弃用_事件_列表_项模板调整坐标1)(hEle, pItem, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}

// AddEvent_List_DrawItem 添加列表项绘制事件.
//
// pFun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (l *X结构_列表) AddEvent_List_DrawItem(pFun X事件_列表_绘制项1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(l.X句柄, xcc.X元素事件_列表_绘制项, onXE_LIST_DRAWITEM, pFun, allowAddingMultiple...)
}

// onXE_LIST_DRAWITEM 列表项绘制事件.
func onXE_LIST_DRAWITEM(hEle int, hDraw int, pItem *xc.X结构_列表项, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hEle, xcc.X元素事件_列表_绘制项)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_列表_绘制项1)(hEle, hDraw, pItem, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}

// AddEvent_List_Select 添加列表项选择事件.
//
// pFun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (l *X结构_列表) AddEvent_List_Select(pFun X事件_列表_项选择1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(l.X句柄, xcc.X元素事件_列表_项选择, onXE_LIST_SELECT, pFun, allowAddingMultiple...)
}

// onXE_LIST_SELECT 列表项选择事件.
func onXE_LIST_SELECT(hEle int, iItem int32, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hEle, xcc.X元素事件_列表_项选择)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_列表_项选择1)(hEle, iItem, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}

// AddEvent_List_Header_DrawItem 添加列表头项绘制事件.
//
// pFun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (l *X结构_列表) AddEvent_List_Header_DrawItem(pFun X事件_列表_列表元素绘制列表头项1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(l.X句柄, xcc.X元素事件_列表_绘制列表头项, onXE_LIST_HEADER_DRAWITEM, pFun, allowAddingMultiple...)
}

// onXE_LIST_HEADER_DRAWITEM 列表头项绘制事件.
func onXE_LIST_HEADER_DRAWITEM(hEle int, hDraw int, pItem *xc.X结构_列表头项, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hEle, xcc.X元素事件_列表_绘制列表头项)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_列表_列表元素绘制列表头项1)(hEle, hDraw, pItem, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}

// AddEvent_List_Header_Click 添加列表头项点击事件.
//
// pFun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (l *X结构_列表) AddEvent_List_Header_Click(pFun X事件_列表_列表头项点击1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(l.X句柄, xcc.X元素事件_列表_列表头项点击, onXE_LIST_HEADER_CLICK, pFun, allowAddingMultiple...)
}

// onXE_LIST_HEADER_CLICK 列表头项点击事件.
func onXE_LIST_HEADER_CLICK(hEle int, iItem int32, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hEle, xcc.X元素事件_列表_列表头项点击)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_列表_列表头项点击1)(hEle, iItem, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}

// AddEvent_List_Header_Width_Change 添加列表头项宽度改变事件.
//
// pFun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (l *X结构_列表) AddEvent_List_Header_Width_Change(pFun X事件_列表_列表头项宽度改变1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(l.X句柄, xcc.X元素事件_列表_列表头项宽度改变, onXE_LIST_HEADER_WIDTH_CHANGE, pFun, allowAddingMultiple...)
}

// onXE_LIST_HEADER_WIDTH_CHANGE 列表头项宽度改变事件.
func onXE_LIST_HEADER_WIDTH_CHANGE(hEle int, iItem int32, nWidth int32, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hEle, xcc.X元素事件_列表_列表头项宽度改变)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_列表_列表头项宽度改变1)(hEle, iItem, nWidth, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}

// AddEvent_List_Header_Temp_Create 添加列表头项模板创建事件.
//
// pFun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (l *X结构_列表) AddEvent_List_Header_Temp_Create(pFun X事件_列表_列表头项模板创建1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(l.X句柄, xcc.X元素事件_列表_列表头项模板创建, onXE_LIST_HEADER_TEMP_CREATE, pFun, allowAddingMultiple...)
}

// onXE_LIST_HEADER_TEMP_CREATE 列表头项模板创建事件.
func onXE_LIST_HEADER_TEMP_CREATE(hEle int, pItem *xc.X结构_列表头项, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hEle, xcc.X元素事件_列表_列表头项模板创建)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_列表_列表头项模板创建1)(hEle, pItem, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}

// AddEvent_List_Header_Temp_Create_End 添加列表头项模板创建完成事件.
//
// pFun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (l *X结构_列表) AddEvent_List_Header_Temp_Create_End(pFun X事件_列表_列表头项模板创建完成1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(l.X句柄, xcc.X元素事件_列表_列表头项模板创建完成, onXE_LIST_HEADER_TEMP_CREATE_END, pFun, allowAddingMultiple...)
}

// onXE_LIST_HEADER_TEMP_CREATE_END 列表头项模板创建完成事件.
func onXE_LIST_HEADER_TEMP_CREATE_END(hEle int, pItem *xc.X结构_列表头项, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hEle, xcc.X元素事件_列表_列表头项模板创建完成)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_列表_列表头项模板创建完成1)(hEle, pItem, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}

// AddEvent_List_Header_Temp_Destroy 添加列表头项模板销毁事件.
//
// pFun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (l *X结构_列表) AddEvent_List_Header_Temp_Destroy(pFun X事件_列表_列表头项模板销毁1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(l.X句柄, xcc.X元素事件_列表_列表头项模板销毁, onXE_LIST_HEADER_TEMP_DESTROY, pFun, allowAddingMultiple...)
}

// onXE_LIST_HEADER_TEMP_DESTROY 列表头项模板销毁事件.
func onXE_LIST_HEADER_TEMP_DESTROY(hEle int, pItem *xc.X结构_列表头项, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hEle, xcc.X元素事件_列表_列表头项模板销毁)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_列表_列表头项模板销毁1)(hEle, pItem, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}

// AddEvent_List_Header_Temp_Adjust_Coordinate 添加列表头项模板调整坐标事件. 已停用.
//
// pFun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (l *X结构_列表) AddEvent_List_Header_Temp_Adjust_Coordinate(pFun X弃用_事件_列表_列表头项模板调整坐标1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(l.X句柄, xcc.X元素事件_列表_列表头项模板调整坐标_已停用, onXE_LIST_HEADER_TEMP_ADJUST_COORDINATE, pFun, allowAddingMultiple...)
}

// onXE_LIST_HEADER_TEMP_ADJUST_COORDINATE 列表头项模板调整坐标事件.
func onXE_LIST_HEADER_TEMP_ADJUST_COORDINATE(hEle int, pItem *xc.X结构_列表头项, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hEle, xcc.X元素事件_列表_列表头项模板调整坐标_已停用)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X弃用_事件_列表_列表头项模板调整坐标1)(hEle, pItem, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}
